package com.boot.springBoot.common.array;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.BlockingDeque;

/**
 * 
    * @ClassName: ArrayUtil  
    * @Description: TODO(
    * 数据结构中最基本的一个结构就是线性结构，而线性结构又分为连续存储结构（数组）和离散存储结构（链表）。所谓的连续存储结构其实就是数组。
	     优点：查询较快如果知道坐标可以快速去地存取 在内存中是一块连续的存储的单元
	     缺点：删除慢,大小固定     删除一个元素得重新排列和移位  改变元素得排列位置
    * @author ysp  
    * @date 2019年5月9日  
    *  
    * @param <T>
 */
@Slf4j
public class ArrayUtil<T> implements Array<T>{
	
	private Object[] data;
	
	private int size;
	
	/**
	 *   有参构造函数
	     * 创建一个新的实例 ArrayUtil.  
	     *  
	     * @param capacity
	 */
	public ArrayUtil(int capacity) {
		data = new Object[capacity];
		size = 0;
	}
	
	/**
	 * 无参构造函数
	     * 创建一个新的实例 ArrayUtil.  
	     *
	 */
	public ArrayUtil() {
		this(capacity);
	}
	
	@Override
	public int getSize() {
		// TODO Auto-generated method stub
		return size;
	}

	@Override
	public int getCapacity() {
		return data.length;
	}

	@Override
	public int hashCode() {
		return super.hashCode();
	}

	/**
	 * 参数判断三原则：
	 * 1.空不空
	 * 2.合不合法  正常的运算逻辑
	 * 3.符不符合业务逻辑 能不能支撑当前业务
	 *
	 * @param index
	 * @param t
	 */
	@Override
	public void add(int index, T t) {
		if (index < 0 || index > size){
			throw new IllegalArgumentException("添加元素失败，索引值不能小于0，并且索引的值不能大于数组的大小");
		}
		if (size == data.length){
			throw new IllegalArgumentException("添加失败，数组的大小已经等于了数组容量的大小");
		}
		if (size == data.length){
			resize(data.length*2);
		}
		/**
		 * index = 2 size = 5
		 * 从添加元素的位置开始  后面的元素全部后移
		 * 循环后移元素到添加的索引位置停止
 		 */
		for (int i = size -1; i >= index; i--) {
			//移位 原来的3 变成现在的4 原来的4 变成5 添加一个元素 大小size变 索引位置变
			data[i+1] = data[i];
		}
		data[index] = t;
		size++;
	}

	@Override
	public void addFirst(T t) {
		add(0,t);
	}

	@Override
	public void addLast(T t) {
		add(size,t);
	}

	@Override
	public void set(int index, T t) {
		if (index < 0 || index >= size){
			throw new IllegalArgumentException("修改值失败，索引值无效");
		}
		data[index] = t;
	}


	/**
	 * 1.index =3
	 * 2.那么 4 5 6 向前移一位
	 * 3.  0   1	2	3	4	5
	 * @param index
	 * @return
	 */
	@Override
	public T remove(int index) {
		if(index <0 || index >=size){
			throw new IllegalArgumentException("删除失败，索引值不存在");
		}
		T t = (T) data[index];
		for (int i = index + 1; i < size; i++) {
			data[i-1]=data[i];
		}
		size--;
		if (size == data.length/4){
			resize(data.length/2);
		}
		return t;
	}

	@Override
	public T removeFirst() {
		return remove(0);
	}

	@Override
	public T removeLast() {
		return remove(size - 1);
	}

	@Override
	public boolean equals(Object obj) {
		return super.equals(obj);
	}


	@Override
	public boolean isEmpty() {
		return size == 0;
	}

	/**
	 * 扩容
	 */
	@Override
	public void resize(int resize) {
		Object[] newData = new Object[resize];
		for (int i = 0; i < size; i++) {
			newData[i] = data[i];
		}
		data = newData;
	}

	@Override
	public boolean contains() {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public int firstIndex() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int lastIndex() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int getIndex() {
		return 0;
	}

	@Override
	public String toString() {
		StringBuffer str = new StringBuffer();
		str.append("Array: size = "+size+" ，capacity = data.length \n");
		str.append("[");
		for (int i = 0; i < size; i++) {
			str.append(data[i]);
			if (i != size-1) {
				str.append(",");
			}

		}
		str.append("]");
		return str.toString();
	}

	public static void main(String[] args) {
		ArrayUtil<Integer> list = new  ArrayUtil();
		for (int i = 0; i < 10; i++) {
			list.add(i,i);
		}
		list.set(10 ,100);
		log.info("得到的数组："+list.toString());
	}

}
